home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / include / linux / virtio_ring.h < prev    next >
C/C++ Source or Header  |  2009-10-16  |  3KB  |  114 lines
  1. #ifndef _LINUX_VIRTIO_RING_H
  2. #define _LINUX_VIRTIO_RING_H
  3. /* An interface for efficient virtio implementation, currently for use by KVM
  4.  * and lguest, but hopefully others soon.  Do NOT change this since it will
  5.  * break existing servers and clients.
  6.  *
  7.  * This header is BSD licensed so anyone can use the definitions to implement
  8.  * compatible drivers/servers.
  9.  *
  10.  * Copyright Rusty Russell IBM Corporation 2007. */
  11. #include <linux/types.h>
  12.  
  13. /* This marks a buffer as continuing via the next field. */
  14. #define VRING_DESC_F_NEXT    1
  15. /* This marks a buffer as write-only (otherwise read-only). */
  16. #define VRING_DESC_F_WRITE    2
  17. /* This means the buffer contains a list of buffer descriptors. */
  18. #define VRING_DESC_F_INDIRECT    4
  19.  
  20. /* The Host uses this in used->flags to advise the Guest: don't kick me when
  21.  * you add a buffer.  It's unreliable, so it's simply an optimization.  Guest
  22.  * will still kick if it's out of buffers. */
  23. #define VRING_USED_F_NO_NOTIFY    1
  24. /* The Guest uses this in avail->flags to advise the Host: don't interrupt me
  25.  * when you consume a buffer.  It's unreliable, so it's simply an
  26.  * optimization.  */
  27. #define VRING_AVAIL_F_NO_INTERRUPT    1
  28.  
  29. /* We support indirect buffer descriptors */
  30. #define VIRTIO_RING_F_INDIRECT_DESC    28
  31.  
  32. /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
  33. struct vring_desc {
  34.     /* Address (guest-physical). */
  35.     __u64 addr;
  36.     /* Length. */
  37.     __u32 len;
  38.     /* The flags as indicated above. */
  39.     __u16 flags;
  40.     /* We chain unused descriptors via this, too */
  41.     __u16 next;
  42. };
  43.  
  44. struct vring_avail {
  45.     __u16 flags;
  46.     __u16 idx;
  47.     __u16 ring[];
  48. };
  49.  
  50. /* u32 is used here for ids for padding reasons. */
  51. struct vring_used_elem {
  52.     /* Index of start of used descriptor chain. */
  53.     __u32 id;
  54.     /* Total length of the descriptor chain which was used (written to) */
  55.     __u32 len;
  56. };
  57.  
  58. struct vring_used {
  59.     __u16 flags;
  60.     __u16 idx;
  61.     struct vring_used_elem ring[];
  62. };
  63.  
  64. struct vring {
  65.     unsigned int num;
  66.  
  67.     struct vring_desc *desc;
  68.  
  69.     struct vring_avail *avail;
  70.  
  71.     struct vring_used *used;
  72. };
  73.  
  74. /* The standard layout for the ring is a continuous chunk of memory which looks
  75.  * like this.  We assume num is a power of 2.
  76.  *
  77.  * struct vring
  78.  * {
  79.  *    // The actual descriptors (16 bytes each)
  80.  *    struct vring_desc desc[num];
  81.  *
  82.  *    // A ring of available descriptor heads with free-running index.
  83.  *    __u16 avail_flags;
  84.  *    __u16 avail_idx;
  85.  *    __u16 available[num];
  86.  *
  87.  *    // Padding to the next align boundary.
  88.  *    char pad[];
  89.  *
  90.  *    // A ring of used descriptor heads with free-running index.
  91.  *    __u16 used_flags;
  92.  *    __u16 used_idx;
  93.  *    struct vring_used_elem used[num];
  94.  * };
  95.  */
  96. static __inline__ void vring_init(struct vring *vr, unsigned int num, void *p,
  97.                   unsigned long align)
  98. {
  99.     vr->num = num;
  100.     vr->desc = p;
  101.     vr->avail = p + num*sizeof(struct vring_desc);
  102.     vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + align-1)
  103.                 & ~(align - 1));
  104. }
  105.  
  106. static __inline__ unsigned vring_size(unsigned int num, unsigned long align)
  107. {
  108.     return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (2 + num)
  109.          + align - 1) & ~(align - 1))
  110.         + sizeof(__u16) * 2 + sizeof(struct vring_used_elem) * num;
  111. }
  112.  
  113. #endif /* _LINUX_VIRTIO_RING_H */
  114.